// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.sales.withdraw.product;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.SalesWithdrawProduct;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(SalesWithdrawProduct.class)
@Setter
@Getter
public class SalesWithdrawProductSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "SalesWithdrawProduct".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("productName", "p");
    map.put("parentSalesWithdraw", "sw");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 平台单号(模糊搜索)
   */
  private String platformOrderNo;

  /**
   * 平台单号 比较(eq)
   */
  private String platformOrderNoEq;
  /**
   * 平台单号 比较(neq)
   */
  private String platformOrderNoNeq;
  /**
   * 平台单号 比较(gt)
   */
  private String platformOrderNoGt;
  /**
   * 平台单号 比较(gte)
   */
  private String platformOrderNoGte;
  /**
   * 平台单号 比较(lt)
   */
  private String platformOrderNoLt;
  /**
   * 平台单号 比较(lte)
   */
  private String platformOrderNoLte;
  /**
   * 平台单号 比较(contains)
   */
  private String platformOrderNoContains;
  /**
   * 平台单号 比较(notcontains)
   */
  private String platformOrderNoNotcontains;
  /**
   * 平台单号 比较(startswith)
   */
  private String platformOrderNoStartswith;
  /**
   * 平台单号 比较(endswith)
   */
  private String platformOrderNoEndswith;
  /**
   * 平台单号 比较(isnull)
   */
  private Boolean platformOrderNoIsnull;
  /**
   * 平台单号 比较(isnotnull)
   */
  private Boolean platformOrderNoIsnotnull;

  /**
   * 平台单号(精确搜索)
   */
  private List<String> platformOrderNoInList;

  /**
   * 是否有 图片
   */
  private Boolean imgUrl;

  /**
   * 商品信息(模糊搜索)
   */
  private String productInfo;

  /**
   * 商品信息 比较(eq)
   */
  private String productInfoEq;
  /**
   * 商品信息 比较(neq)
   */
  private String productInfoNeq;
  /**
   * 商品信息 比较(gt)
   */
  private String productInfoGt;
  /**
   * 商品信息 比较(gte)
   */
  private String productInfoGte;
  /**
   * 商品信息 比较(lt)
   */
  private String productInfoLt;
  /**
   * 商品信息 比较(lte)
   */
  private String productInfoLte;
  /**
   * 商品信息 比较(contains)
   */
  private String productInfoContains;
  /**
   * 商品信息 比较(notcontains)
   */
  private String productInfoNotcontains;
  /**
   * 商品信息 比较(startswith)
   */
  private String productInfoStartswith;
  /**
   * 商品信息 比较(endswith)
   */
  private String productInfoEndswith;
  /**
   * 商品信息 比较(isnull)
   */
  private Boolean productInfoIsnull;
  /**
   * 商品信息 比较(isnotnull)
   */
  private Boolean productInfoIsnotnull;

  /**
   * 商品信息(精确搜索)
   */
  private List<String> productInfoInList;

  /**
   * 品名
   */
  private Long productName;

  /**
   * 品名 比较(eq)
   */
  private Long productNameEq;
  /**
   * 品名 比较(neq)
   */
  private Long productNameNeq;
  /**
   * 品名 比较(gt)
   */
  private Long productNameGt;
  /**
   * 品名 比较(gte)
   */
  private Long productNameGte;
  /**
   * 品名 比较(lt)
   */
  private Long productNameLt;
  /**
   * 品名 比较(lte)
   */
  private Long productNameLte;
  /**
   * 品名 比较(contains)
   */
  private Long productNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long productNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long productNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long productNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String productNameNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String productNameNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String productNameNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String productNameNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String productNameNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String productNameNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String productNameNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String productNameNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String productNameNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String productNameNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean productNameNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean productNameNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> productNameInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 最早订购时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderTimeStart;

  /**
   * 最晚订购时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderTimeEnd;

  /**
   * 订购时间 比较(eq)
   */
  private Date orderTimeEq;
  /**
   * 订购时间 比较(neq)
   */
  private Date orderTimeNeq;
  /**
   * 订购时间 比较(gt)
   */
  private Date orderTimeGt;
  /**
   * 订购时间 比较(gte)
   */
  private Date orderTimeGte;
  /**
   * 订购时间 比较(lt)
   */
  private Date orderTimeLt;
  /**
   * 订购时间 比较(lte)
   */
  private Date orderTimeLte;
  /**
   * 订购时间 比较(contains)
   */
  private Date orderTimeContains;
  /**
   * 订购时间 比较(notcontains)
   */
  private Date orderTimeNotcontains;
  /**
   * 订购时间 比较(startswith)
   */
  private Date orderTimeStartswith;
  /**
   * 订购时间 比较(endswith)
   */
  private Date orderTimeEndswith;
  /**
   * 订购时间 比较(isnull)
   */
  private Boolean orderTimeIsnull;
  /**
   * 订购时间 比较(isnotnull)
   */
  private Boolean orderTimeIsnotnull;

  /**
   * 退货数量
   */
  private Integer returnQuantity;

  /**
   * 最小退货数量
   */
  private Integer returnQuantityMin;

  /**
   * 最大退货数量
   */
  private Integer returnQuantityMax;

  /**
   * 退货数量 比较(eq)
   */
  private Integer returnQuantityEq;
  /**
   * 退货数量 比较(neq)
   */
  private Integer returnQuantityNeq;
  /**
   * 退货数量 比较(gt)
   */
  private Integer returnQuantityGt;
  /**
   * 退货数量 比较(gte)
   */
  private Integer returnQuantityGte;
  /**
   * 退货数量 比较(lt)
   */
  private Integer returnQuantityLt;
  /**
   * 退货数量 比较(lte)
   */
  private Integer returnQuantityLte;
  /**
   * 退货数量 比较(contains)
   */
  private Integer returnQuantityContains;
  /**
   * 退货数量 比较(notcontains)
   */
  private Integer returnQuantityNotcontains;
  /**
   * 退货数量 比较(startswith)
   */
  private Integer returnQuantityStartswith;
  /**
   * 退货数量 比较(endswith)
   */
  private Integer returnQuantityEndswith;
  /**
   * 退货数量 比较(isnull)
   */
  private Boolean returnQuantityIsnull;
  /**
   * 退货数量 比较(isnotnull)
   */
  private Boolean returnQuantityIsnotnull;

  /**
   * 收货量
   */
  private Integer receivingQuantity;

  /**
   * 最小收货量
   */
  private Integer receivingQuantityMin;

  /**
   * 最大收货量
   */
  private Integer receivingQuantityMax;

  /**
   * 收货量 比较(eq)
   */
  private Integer receivingQuantityEq;
  /**
   * 收货量 比较(neq)
   */
  private Integer receivingQuantityNeq;
  /**
   * 收货量 比较(gt)
   */
  private Integer receivingQuantityGt;
  /**
   * 收货量 比较(gte)
   */
  private Integer receivingQuantityGte;
  /**
   * 收货量 比较(lt)
   */
  private Integer receivingQuantityLt;
  /**
   * 收货量 比较(lte)
   */
  private Integer receivingQuantityLte;
  /**
   * 收货量 比较(contains)
   */
  private Integer receivingQuantityContains;
  /**
   * 收货量 比较(notcontains)
   */
  private Integer receivingQuantityNotcontains;
  /**
   * 收货量 比较(startswith)
   */
  private Integer receivingQuantityStartswith;
  /**
   * 收货量 比较(endswith)
   */
  private Integer receivingQuantityEndswith;
  /**
   * 收货量 比较(isnull)
   */
  private Boolean receivingQuantityIsnull;
  /**
   * 收货量 比较(isnotnull)
   */
  private Boolean receivingQuantityIsnotnull;

  /**
   * 售后图片(模糊搜索)
   */
  private String salesImg;

  /**
   * 售后图片 比较(eq)
   */
  private String salesImgEq;
  /**
   * 售后图片 比较(neq)
   */
  private String salesImgNeq;
  /**
   * 售后图片 比较(gt)
   */
  private String salesImgGt;
  /**
   * 售后图片 比较(gte)
   */
  private String salesImgGte;
  /**
   * 售后图片 比较(lt)
   */
  private String salesImgLt;
  /**
   * 售后图片 比较(lte)
   */
  private String salesImgLte;
  /**
   * 售后图片 比较(contains)
   */
  private String salesImgContains;
  /**
   * 售后图片 比较(notcontains)
   */
  private String salesImgNotcontains;
  /**
   * 售后图片 比较(startswith)
   */
  private String salesImgStartswith;
  /**
   * 售后图片 比较(endswith)
   */
  private String salesImgEndswith;
  /**
   * 售后图片 比较(isnull)
   */
  private Boolean salesImgIsnull;
  /**
   * 售后图片 比较(isnotnull)
   */
  private Boolean salesImgIsnotnull;

  /**
   * 售后图片(精确搜索)
   */
  private List<String> salesImgInList;

  /**
   * 处理方式(模糊搜索)
   */
  private String handlerType;

  /**
   * 处理方式 比较(eq)
   */
  private String handlerTypeEq;
  /**
   * 处理方式 比较(neq)
   */
  private String handlerTypeNeq;
  /**
   * 处理方式 比较(gt)
   */
  private String handlerTypeGt;
  /**
   * 处理方式 比较(gte)
   */
  private String handlerTypeGte;
  /**
   * 处理方式 比较(lt)
   */
  private String handlerTypeLt;
  /**
   * 处理方式 比较(lte)
   */
  private String handlerTypeLte;
  /**
   * 处理方式 比较(contains)
   */
  private String handlerTypeContains;
  /**
   * 处理方式 比较(notcontains)
   */
  private String handlerTypeNotcontains;
  /**
   * 处理方式 比较(startswith)
   */
  private String handlerTypeStartswith;
  /**
   * 处理方式 比较(endswith)
   */
  private String handlerTypeEndswith;
  /**
   * 处理方式 比较(isnull)
   */
  private Boolean handlerTypeIsnull;
  /**
   * 处理方式 比较(isnotnull)
   */
  private Boolean handlerTypeIsnotnull;

  /**
   * 处理方式(精确搜索)
   */
  private List<String> handlerTypeInList;

  /**
   * 售后说明(模糊搜索)
   */
  private String remark;

  /**
   * 售后说明 比较(eq)
   */
  private String remarkEq;
  /**
   * 售后说明 比较(neq)
   */
  private String remarkNeq;
  /**
   * 售后说明 比较(gt)
   */
  private String remarkGt;
  /**
   * 售后说明 比较(gte)
   */
  private String remarkGte;
  /**
   * 售后说明 比较(lt)
   */
  private String remarkLt;
  /**
   * 售后说明 比较(lte)
   */
  private String remarkLte;
  /**
   * 售后说明 比较(contains)
   */
  private String remarkContains;
  /**
   * 售后说明 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 售后说明 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 售后说明 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 售后说明 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 售后说明 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 售后说明(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 数量
   */
  private Integer quantity;

  /**
   * 最小数量
   */
  private Integer quantityMin;

  /**
   * 最大数量
   */
  private Integer quantityMax;

  /**
   * 数量 比较(eq)
   */
  private Integer quantityEq;
  /**
   * 数量 比较(neq)
   */
  private Integer quantityNeq;
  /**
   * 数量 比较(gt)
   */
  private Integer quantityGt;
  /**
   * 数量 比较(gte)
   */
  private Integer quantityGte;
  /**
   * 数量 比较(lt)
   */
  private Integer quantityLt;
  /**
   * 数量 比较(lte)
   */
  private Integer quantityLte;
  /**
   * 数量 比较(contains)
   */
  private Integer quantityContains;
  /**
   * 数量 比较(notcontains)
   */
  private Integer quantityNotcontains;
  /**
   * 数量 比较(startswith)
   */
  private Integer quantityStartswith;
  /**
   * 数量 比较(endswith)
   */
  private Integer quantityEndswith;
  /**
   * 数量 比较(isnull)
   */
  private Boolean quantityIsnull;
  /**
   * 数量 比较(isnotnull)
   */
  private Boolean quantityIsnotnull;

  /**
   * 销毁量
   */
  private Integer destroyedQuantity;

  /**
   * 最小销毁量
   */
  private Integer destroyedQuantityMin;

  /**
   * 最大销毁量
   */
  private Integer destroyedQuantityMax;

  /**
   * 销毁量 比较(eq)
   */
  private Integer destroyedQuantityEq;
  /**
   * 销毁量 比较(neq)
   */
  private Integer destroyedQuantityNeq;
  /**
   * 销毁量 比较(gt)
   */
  private Integer destroyedQuantityGt;
  /**
   * 销毁量 比较(gte)
   */
  private Integer destroyedQuantityGte;
  /**
   * 销毁量 比较(lt)
   */
  private Integer destroyedQuantityLt;
  /**
   * 销毁量 比较(lte)
   */
  private Integer destroyedQuantityLte;
  /**
   * 销毁量 比较(contains)
   */
  private Integer destroyedQuantityContains;
  /**
   * 销毁量 比较(notcontains)
   */
  private Integer destroyedQuantityNotcontains;
  /**
   * 销毁量 比较(startswith)
   */
  private Integer destroyedQuantityStartswith;
  /**
   * 销毁量 比较(endswith)
   */
  private Integer destroyedQuantityEndswith;
  /**
   * 销毁量 比较(isnull)
   */
  private Boolean destroyedQuantityIsnull;
  /**
   * 销毁量 比较(isnotnull)
   */
  private Boolean destroyedQuantityIsnotnull;

  /**
   * 次品量
   */
  private Integer defectiveQuantity;

  /**
   * 最小次品量
   */
  private Integer defectiveQuantityMin;

  /**
   * 最大次品量
   */
  private Integer defectiveQuantityMax;

  /**
   * 次品量 比较(eq)
   */
  private Integer defectiveQuantityEq;
  /**
   * 次品量 比较(neq)
   */
  private Integer defectiveQuantityNeq;
  /**
   * 次品量 比较(gt)
   */
  private Integer defectiveQuantityGt;
  /**
   * 次品量 比较(gte)
   */
  private Integer defectiveQuantityGte;
  /**
   * 次品量 比较(lt)
   */
  private Integer defectiveQuantityLt;
  /**
   * 次品量 比较(lte)
   */
  private Integer defectiveQuantityLte;
  /**
   * 次品量 比较(contains)
   */
  private Integer defectiveQuantityContains;
  /**
   * 次品量 比较(notcontains)
   */
  private Integer defectiveQuantityNotcontains;
  /**
   * 次品量 比较(startswith)
   */
  private Integer defectiveQuantityStartswith;
  /**
   * 次品量 比较(endswith)
   */
  private Integer defectiveQuantityEndswith;
  /**
   * 次品量 比较(isnull)
   */
  private Boolean defectiveQuantityIsnull;
  /**
   * 次品量 比较(isnotnull)
   */
  private Boolean defectiveQuantityIsnotnull;

  /**
   * 可用量
   */
  private Integer availableQuantity;

  /**
   * 最小可用量
   */
  private Integer availableQuantityMin;

  /**
   * 最大可用量
   */
  private Integer availableQuantityMax;

  /**
   * 可用量 比较(eq)
   */
  private Integer availableQuantityEq;
  /**
   * 可用量 比较(neq)
   */
  private Integer availableQuantityNeq;
  /**
   * 可用量 比较(gt)
   */
  private Integer availableQuantityGt;
  /**
   * 可用量 比较(gte)
   */
  private Integer availableQuantityGte;
  /**
   * 可用量 比较(lt)
   */
  private Integer availableQuantityLt;
  /**
   * 可用量 比较(lte)
   */
  private Integer availableQuantityLte;
  /**
   * 可用量 比较(contains)
   */
  private Integer availableQuantityContains;
  /**
   * 可用量 比较(notcontains)
   */
  private Integer availableQuantityNotcontains;
  /**
   * 可用量 比较(startswith)
   */
  private Integer availableQuantityStartswith;
  /**
   * 可用量 比较(endswith)
   */
  private Integer availableQuantityEndswith;
  /**
   * 可用量 比较(isnull)
   */
  private Boolean availableQuantityIsnull;
  /**
   * 可用量 比较(isnotnull)
   */
  private Boolean availableQuantityIsnotnull;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 所属销售退货单
   */
  private Long parentSalesWithdraw;

  /**
   * 所属销售退货单 比较(eq)
   */
  private Long parentSalesWithdrawEq;
  /**
   * 所属销售退货单 比较(neq)
   */
  private Long parentSalesWithdrawNeq;
  /**
   * 所属销售退货单 比较(gt)
   */
  private Long parentSalesWithdrawGt;
  /**
   * 所属销售退货单 比较(gte)
   */
  private Long parentSalesWithdrawGte;
  /**
   * 所属销售退货单 比较(lt)
   */
  private Long parentSalesWithdrawLt;
  /**
   * 所属销售退货单 比较(lte)
   */
  private Long parentSalesWithdrawLte;
  /**
   * 所属销售退货单 比较(contains)
   */
  private Long parentSalesWithdrawContains;
  /**
   * 所属销售退货单 比较(notcontains)
   */
  private Long parentSalesWithdrawNotcontains;
  /**
   * 所属销售退货单 比较(startswith)
   */
  private Long parentSalesWithdrawStartswith;
  /**
   * 所属销售退货单 比较(endswith)
   */
  private Long parentSalesWithdrawEndswith;
  /**
   * 所属销售退货单 比较(isnull)
   */
  private Boolean parentSalesWithdrawIsnull;
  /**
   * 所属销售退货单 比较(isnotnull)
   */
  private Boolean parentSalesWithdrawIsnotnull;
  /**
   * 所属销售退货单的系统单号 比较(eq)
   */
  private String parentSalesWithdrawGlobalOrderNoEq;
  /**
   * 所属销售退货单的系统单号 比较(neq)
   */
  private String parentSalesWithdrawGlobalOrderNoNeq;
  /**
   * 所属销售退货单的系统单号 比较(gt)
   */
  private String parentSalesWithdrawGlobalOrderNoGt;
  /**
   * 所属销售退货单的系统单号 比较(gte)
   */
  private String parentSalesWithdrawGlobalOrderNoGte;
  /**
   * 所属销售退货单的系统单号 比较(lt)
   */
  private String parentSalesWithdrawGlobalOrderNoLt;
  /**
   * 所属销售退货单的系统单号 比较(lte)
   */
  private String parentSalesWithdrawGlobalOrderNoLte;
  /**
   * 所属销售退货单的系统单号 比较(contains)
   */
  private String parentSalesWithdrawGlobalOrderNoContains;
  /**
   * 所属销售退货单的系统单号 比较(notcontains)
   */
  private String parentSalesWithdrawGlobalOrderNoNotcontains;
  /**
   * 所属销售退货单的系统单号 比较(startswith)
   */
  private String parentSalesWithdrawGlobalOrderNoStartswith;
  /**
   * 所属销售退货单的系统单号 比较(endswith)
   */
  private String parentSalesWithdrawGlobalOrderNoEndswith;
  /**
   * 所属销售退货单的系统单号 比较(isnull)
   */
  private Boolean parentSalesWithdrawGlobalOrderNoIsnull;
  /**
   * 所属销售退货单的系统单号 比较(isnotnull)
   */
  private Boolean parentSalesWithdrawGlobalOrderNoIsnotnull;

  /**
   * 所属销售退货单(范围搜索)
   */
  private List<Long> parentSalesWithdrawInList;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 产品id
   */
  private Long pid;

  /**
   * 最小产品id
   */
  private Long pidMin;

  /**
   * 最大产品id
   */
  private Long pidMax;

  /**
   * 产品id 比较(eq)
   */
  private Long pidEq;
  /**
   * 产品id 比较(neq)
   */
  private Long pidNeq;
  /**
   * 产品id 比较(gt)
   */
  private Long pidGt;
  /**
   * 产品id 比较(gte)
   */
  private Long pidGte;
  /**
   * 产品id 比较(lt)
   */
  private Long pidLt;
  /**
   * 产品id 比较(lte)
   */
  private Long pidLte;
  /**
   * 产品id 比较(contains)
   */
  private Long pidContains;
  /**
   * 产品id 比较(notcontains)
   */
  private Long pidNotcontains;
  /**
   * 产品id 比较(startswith)
   */
  private Long pidStartswith;
  /**
   * 产品id 比较(endswith)
   */
  private Long pidEndswith;
  /**
   * 产品id 比较(isnull)
   */
  private Boolean pidIsnull;
  /**
   * 产品id 比较(isnotnull)
   */
  private Boolean pidIsnotnull;

  /**
   * 单位出库成本
   */
  private java.math.BigDecimal outboundCost;

  /**
   * 最小单位出库成本
   */
  private java.math.BigDecimal outboundCostMin;

  /**
   * 最大单位出库成本
   */
  private java.math.BigDecimal outboundCostMax;

  /**
   * 单位出库成本 比较(eq)
   */
  private java.math.BigDecimal outboundCostEq;
  /**
   * 单位出库成本 比较(neq)
   */
  private java.math.BigDecimal outboundCostNeq;
  /**
   * 单位出库成本 比较(gt)
   */
  private java.math.BigDecimal outboundCostGt;
  /**
   * 单位出库成本 比较(gte)
   */
  private java.math.BigDecimal outboundCostGte;
  /**
   * 单位出库成本 比较(lt)
   */
  private java.math.BigDecimal outboundCostLt;
  /**
   * 单位出库成本 比较(lte)
   */
  private java.math.BigDecimal outboundCostLte;
  /**
   * 单位出库成本 比较(contains)
   */
  private java.math.BigDecimal outboundCostContains;
  /**
   * 单位出库成本 比较(notcontains)
   */
  private java.math.BigDecimal outboundCostNotcontains;
  /**
   * 单位出库成本 比较(startswith)
   */
  private java.math.BigDecimal outboundCostStartswith;
  /**
   * 单位出库成本 比较(endswith)
   */
  private java.math.BigDecimal outboundCostEndswith;
  /**
   * 单位出库成本 比较(isnull)
   */
  private Boolean outboundCostIsnull;
  /**
   * 单位出库成本 比较(isnotnull)
   */
  private Boolean outboundCostIsnotnull;

  /**
   * 可用仓位
   */
  private String availableWbin;

  /**
   * 可用仓位 比较(eq)
   */
  private String availableWbinEq;
  /**
   * 可用仓位 比较(neq)
   */
  private String availableWbinNeq;
  /**
   * 可用仓位 比较(gt)
   */
  private String availableWbinGt;
  /**
   * 可用仓位 比较(gte)
   */
  private String availableWbinGte;
  /**
   * 可用仓位 比较(lt)
   */
  private String availableWbinLt;
  /**
   * 可用仓位 比较(lte)
   */
  private String availableWbinLte;
  /**
   * 可用仓位 比较(contains)
   */
  private String availableWbinContains;
  /**
   * 可用仓位 比较(notcontains)
   */
  private String availableWbinNotcontains;
  /**
   * 可用仓位 比较(startswith)
   */
  private String availableWbinStartswith;
  /**
   * 可用仓位 比较(endswith)
   */
  private String availableWbinEndswith;
  /**
   * 可用仓位 比较(isnull)
   */
  private Boolean availableWbinIsnull;
  /**
   * 可用仓位 比较(isnotnull)
   */
  private Boolean availableWbinIsnotnull;

  /**
   * 可用仓位(精确搜索)
   */
  private List<String> availableWbinInList;

  /**
   * 次品仓位
   */
  private String defectiveWbin;

  /**
   * 次品仓位 比较(eq)
   */
  private String defectiveWbinEq;
  /**
   * 次品仓位 比较(neq)
   */
  private String defectiveWbinNeq;
  /**
   * 次品仓位 比较(gt)
   */
  private String defectiveWbinGt;
  /**
   * 次品仓位 比较(gte)
   */
  private String defectiveWbinGte;
  /**
   * 次品仓位 比较(lt)
   */
  private String defectiveWbinLt;
  /**
   * 次品仓位 比较(lte)
   */
  private String defectiveWbinLte;
  /**
   * 次品仓位 比较(contains)
   */
  private String defectiveWbinContains;
  /**
   * 次品仓位 比较(notcontains)
   */
  private String defectiveWbinNotcontains;
  /**
   * 次品仓位 比较(startswith)
   */
  private String defectiveWbinStartswith;
  /**
   * 次品仓位 比较(endswith)
   */
  private String defectiveWbinEndswith;
  /**
   * 次品仓位 比较(isnull)
   */
  private Boolean defectiveWbinIsnull;
  /**
   * 次品仓位 比较(isnotnull)
   */
  private Boolean defectiveWbinIsnotnull;

  /**
   * 次品仓位(精确搜索)
   */
  private List<String> defectiveWbinInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
